// #include <iostream>
// #include <string>
// #include <cstdio>
// #include <unistd.h>
// #include <vector>

// using namespace std;
// #define NUM 5
// #define SIZE 1024

// // struct threadData
// // {
// //     string threadname;
// //     pthread_t tid;
// // };

// // void *threadRoutine(void *args)
// // {
// //     threadData* td = static_cast<threadData*>(args);
// //     int cnt = 5;
// //     while(cnt--)
// //     {
// //         printf("pid: %d, ppid: %d, tid: %ld %s\n",
// //             getpid(), getppid(), pthread_self(), td->threadname.c_str());

// //         sleep(1);
// //     }

// //     pthread_exit((void*)6666);
// // }

// // void InitThreadData(threadData* td, pthread_t tid)
// // {
// //     td->threadname = "thread-" + to_string(tid);
// //     td->tid = tid;   
// // }

// // int main()
// // {
// //     vector<pthread_t> tids;//进行等待线程id
// //     vector<threadData*> tData; //对申请的堆空间进行保存，方便后续释放
// //     for(int i = 0; i < NUM; i++)
// //     {
// //         pthread_t tid;
// //         threadData* td = new threadData; //堆是所有线程共享资源
// //         tData.push_back(td); //将申请的空间保存起来
// //         pthread_create(&tid, nullptr, threadRoutine, static_cast<void*>(td));
// //         InitThreadData(td, i);
// //         tids.push_back(tid);
// //     }

// //     printf("main thread!!! pid: %d, ppid: %d\n", getpid(), getppid());

// //     usleep(1000);
// //     //线程等待
// //     for(int i = 0; i < NUM; i++)
// //     {
// //         void *exitcode;
// //         pthread_join(tids[i], &exitcode);
// //         printf("exitcode: %d\n", exitcode);
// //     }

// //     for(auto td : tData)
// //     {
// //         delete td;
// //     }

// //     return 0;
// // }


// // __thread int number;

// pthread_t main_pthread;

// struct threadData
// {
//     string threadname;
//     pthread_t tid;
// };

// string toHex(pthread_t tid)
// {
//     char buffer[SIZE];
//     snprintf(buffer, sizeof(buffer) - 1, "0x%lx", tid);
//     return buffer;
// }

// void *threadRoutine(void *args)
// {
//     pthread_detach(pthread_self());

//     threadData* td = static_cast<threadData*>(args);
//     int cnt = 5;
//     while(cnt--)
//     {
//         printf("pid: %d, ppid: %d, tid: %s %s\n",
//         getpid(), getppid(), toHex(pthread_self()).c_str(), td->threadname.c_str());

//         // printf("pid: %d, ppid: %d, tid: %ld %s\n",
//         //     getpid(), getppid(), pthread_self(), td->threadname.c_str());

//         //printf("[pthread_self() fetch] -> tid: %ld [thread fetch] -> tid: %ld \n",
//         //pthread_self(), td->tid);
//         //pthread_cancel(pthread_self());
//         // pthread_cancel(main_pthread);

//         sleep(1);
//     }

//     pthread_exit((void*)6666);
//     // return nullptr;
// }

// void InitThreadData(threadData* td, pthread_t tid)
// {
//     td->threadname = "thread-" + to_string(tid);
//     td->tid = tid;   
// }

// int main()
// {
//     main_pthread = pthread_self();

//     vector<pthread_t> tids;//进行等待线程id
//     vector<threadData*> tData; //对申请的堆空间进行保存，方便后续释放
//     //vector<threadData*> tData; //主线程的栈区
//     for(int i = 0; i < NUM; i++)
//     {
//         pthread_t tid;
//         threadData* td = new threadData; //堆是所有线程共享资源
//         //threadData td; //使用的主线程的栈空间，多次循环将该地址处的修改了，所以新例程执行时全部都是拿到的同一个数据
//         tData.push_back(td); //将申请的空间保存起来
//         pthread_create(&tid, nullptr, threadRoutine, static_cast<void*>(td));
//         InitThreadData(td, tid);
//         // InitThreadData(&td, i);
//         // pthread_create(&tid, nullptr, threadRoutine, static_cast<void*>(&td));
//         tids.push_back(tid);
//     }

//     //在主线程中取消0，1，2线程
//     // for(int i = 0; i < 3; i++)
//     // {
//     //     pthread_cancel(tids[i]);
//     // }

//     // int cnt = 5;
//     while(true)
//     {
//         printf("main thread!!! pid: %d, ppid: %d\n", getpid(), getppid());
//         //printf("[pthread_self() fetch] -> tid: %ld\n", pthread_self());
//         //printf("main thread!!! [pthread_self() fetch] -> tid: %ld\n", pthread_self());

//         sleep(1);
//     }

//     //线程等待
//     // for(int i = 0; i < NUM; i++)
//     // {
//     //     void* ExitCode = nullptr;
//     //     int n = pthread_join(tids[i], &ExitCode);
//     //     if(n == 0)
//     //     {
//     //         printf("thread-%d wait success! exitcode: %d\n", i, ExitCode);
//     //     }
//     //     else
//     //         break;
//     // }

//     for(auto td : tData)
//     {
//         delete td;
//     }

//     return 0;
// }

#include <iostream>
#include <cstdio>
#include <pthread.h>

using namespace std;
#define SIZE 1024

void *threadRoutine(void *args)
{
    char* buffer = static_cast<char*>(args);
    printf("%s tid: %p\n", buffer, pthread_self());

    return nullptr;
}

int main()
{
    pthread_t tid;
    char buffer[SIZE] = "thread-1";
    int n = pthread_create(&tid, nullptr, threadRoutine, static_cast<void*>(buffer));
    if(n != 0)
    {
        perror("main::pthread_create");
        return 1;
    }

    printf("main thread tid: %p\n", pthread_self());

    pthread_join(tid, nullptr);

    return 0;
}